//////////////////////////////////////////////////////////////
//  guarda partido con formato cargable por la aplicacion
void guardaFicheroPartido(String donde) {
  println ("---- Iniciando guardado ----");

  PrintWriter out;
  out = createWriter(donde);

  //  ArrayList<Punto> validos =  CheckConsistency ();  // elimina repeticiones y cosas raras.

  for (int i=0; i< partido.puntos.size(); i++) {
    Punto p = partido.puntos.get(i);
    out.println("---- PUNTO ----");

    out.println("Saca "+ tJugador[p.jugadorQueSaca]);  // = new String[] {"jugador1","jugador2"};
    println ("Saca el jugador: " + p.jugadorQueSaca);


    out.println("---- GOLPES PUNTO ----");
    for (int j=0; j < p.golpes.size(); j++) {
      Golpe g = p.golpes.get(j);
      out.println(g);
    }
    out.println("---- GOLPES TRAYECTORIA ----");
    for (int j=0; j < p.trayectorias.size(); j++) {
      Trayectoria t = p.trayectorias.get(j);
      out.println(t);
    }          
    out.println("---- FIN PUNTO ----");
  }

  out.flush();
  out.close();

  println ("---- guardado finalizado ----");
}

///////////////////////////////////////////////////////////////////
// guarda C4D
void printSpaceSeparated(String donde) { 

  println (path);
  PrintWriter out = createWriter (donde);
  
  String separador = " ";

  for (int i=0; i<partido.puntos.size(); i++) {
    Punto aux = partido.puntos.get(i);
    for (int j=0; j< aux.trayectorias.size(); j++) {
      Trayectoria tr = aux.trayectorias.get(j);

      out.print   (cxm(tr.inicio.pos.x) + separador + cym(tr.inicio.pos.y) + separador + czm(tr.inicio.pos.z) + separador);

      // transform punto V
      float [] pv= new float [3];
      pv[0] = tr.inicio.pos.x + ((tr.fin.pos.x - tr.inicio.pos.x) * tr.puntoV.z);
      pv[1] = tr.puntoV.y;
      pv[2] = tr.inicio.pos.z + ((tr.fin.pos.z - tr.inicio.pos.z) * tr.puntoV.z);

//      println (tr);       
//      println ( tr.puntoV.z + " ->  {" + pv[0] + " " + pv[1] + " " + pv[2] +"}");

      out.print (cxm(pv[0]       )  + separador +  pv[1]               + separador + czm(pv[2])        + separador);
      out.print (cxm(tr.fin.pos.x)  + separador + cym(tr.fin.pos.y)    + separador + czm(tr.fin.pos.z) + separador);
      //out.println("n ");
//      out.print ( tr.inicio.tipo + separador + tr.fin.tipo);
     out.println ( tr.inicio.jugador);
    }
  }
  out.flush();
  out.close();
}

//////////////////////////////////////////////////////////////
//  guarda partido con formato cargable por la aplicacion
ArrayList<Punto>  CheckConsistency() {

  ArrayList<Punto> validos = new ArrayList<Punto>();

  Trayectoria primeraAnterior = null;
  Trayectoria ultimaAnterior  = null;

  for (int i=0; i<partido.puntos.size(); i++) {
    Punto p = partido.puntos.get(i);

    // comprueba que el punto sea coherente
    // comprueba intervalos
    Trayectoria primera = p.trayectorias.get(0); 
    Trayectoria ultima  = p.trayectorias.get(p.trayectorias.size()-1);

    // el punto debe terminar despues de empezar
    if (primera.inicio.frame > ultima.fin.frame) {
      println ("ERROR!! punto incoherente");
      primeraAnterior = primera;
      ultimaAnterior  = ultima;
      continue;
    }

    // para los puntos despues del primero
    if (i>0) {
      // deben empezar despues del final del punto anterior
      if (primera.inicio.frame <= ultimaAnterior.fin.frame) {
        if (primera.inicio.frame == primeraAnterior.inicio.frame) {
          println ("ERROR!! punto repetido");
          println (primera);
          println (primeraAnterior);
          continue;
        }
        else {
          println ("ERROR!! secuencia temporal ");
          println (primera);
          println (primeraAnterior);
          continue;
        }
      }
    }

    validos.add(p);

    primeraAnterior = primera;
    ultimaAnterior  = ultima;
  }// puntos
  return validos;
}

